
const arr = [
    { id: 'root', pid: '' },
    { id: 'ab', pid: 'root' },
    { id: 'baz', pid: 'ab' },
    { id: 'foo', pid: 'baz' },
    { id: 'bar', pid: 'baz' },
]
// 将上面输出为树
/* const obj = [
    {
        id: 'root',
        pid: '',
        children: [
            {
                id: 'ab',
                pid: 'root',
                children: [
                    {
                        id: 'baz',
                        pid: 'ab',
                        children: [
                            {
                                id: 'foo',
                                pid: 'baz',
                            },
                            {
                                id: 'bar',
                                pid: 'baz',
                            },
                        ],
                    },
                ],
            },
        ],

    }
] */

const arrToTree = (list, rootId = 'root') => {
    if (!(Array.isArray(list) && list.length !== 0)) return []
    const arr = Array.from(list)
    const findChildren = (id) => {
        const children = []
        let index = 0
        for (let i = 0; i < arr.length;) {
            const element = arr[i];
            console.log(`${id}-${index}`, element);
            index++
            if (element.pid === id) {
                const hasChild = findChildren(element.id)
                if (hasChild.length) element.children = hasChild
                children.push(element)
                arr.splice(i, 1)
            } else i++
        }
        return children
    }
    const rootChildren = findChildren(rootId)
    const root = arr.find(item => item.id === rootId)
    root.children = rootChildren
    return arr
}
/**
 * 将平铺的数组转换为树状结构。
 * @param {Array} list - 包含元素的数组，每个元素应有id和pid属性。
 * @param {string} rootNodeId - 根节点的id，默认为'root'。
 * @returns {Array} - 转换后的树状结构数组。
 */
/* const arrToTree = (list, rootNodeId = 'root') => {
    if (!Array.isArray(list) || list.length === 0) return []
    
    // 检查每个元素是否包含必要的属性
    const validList = list.filter(item => item.id && item.pid);
    if (validList.length !== list.length) {
        console.warn('输入数组包含不完整数据。');
        return [];
    }
    
    const arr = Array.from(validList);
    const findChildren = (id) => {
        const children = [];
        const processed = []; // 使用标记数组避免修改原数组
        
        for (let i = 0; i < arr.length;) {
            const element = arr[i];
            if (element.pid === id) {
                const hasChild = findChildren(element.id)
                if (hasChild.length) element.children = hasChild
                children.push(element);
                processed.push(i); // 标记已处理元素
            } else if (!processed.includes(i)) { // 跳过已处理元素
                i++;
            }
        }
        // 移除已处理元素
        processed.forEach(index => arr.splice(index, 1));
        return children;
    }
    
    const rootChildren = findChildren(rootNodeId);
    const root = list.find(item => item.id === rootNodeId);
    if (root) {
        root.children = rootChildren;
    } else {
        // 如果不存在根节点，返回空数组
        console.warn(`未找到根节点ID：${rootNodeId}`);
        return [];
    }
    
    // 这里返回原数组list，因为arr和list在开始时是等价的，且root节点的修改在上面已实现
    return list;
} */
const result = arrToTree(arr)
console.log(result, arr);
